home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
C!T ROM 3
/
ct-rom iiib.zip
/
ct-rom iiib
/
WINDOWS
/
DIVERSEN
/
WINE02BX
/
EMACS.2
< prev
next >
Wrap
Text File
|
1993-03-28
|
49KB
|
1,217 lines
Info file ../info/emacs, produced by Makeinfo, -*- Text -*- from input
file lemacs.tex.
This file documents the GNU Emacs editor.
Copyright (C) 1985, 1986, 1988 Richard M. Stallman. Copyright (C)
1991, 1992 Lucid, Inc.
Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
General Public License" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under
the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "The GNU Manifesto",
"Distribution" and "GNU General Public License" may be included in a
translation approved by the author instead of in the original English.
File: emacs, Node: Character Representation, Next: Commands, Prev: Super and Hyper Keys, Up: Keystrokes
Representation of Characters
============================
This section briefly discusses how characters are represented in
Emacs buffers. *Note Key Sequences:: for information on representing
key sequences to create key bindings.
ASCII graphic characters in Emacs buffers are displayed with their
graphics. LFD is the same as a newline character; it is displayed by
starting a new line. TAB is displayed by moving to the next tab stop
column (usually every 8 spaces). Other control characters are
displayed as a caret (`^') followed by the non-control version of the
character; thus, `C-a' is displayed as `^A'. Non-ASCII characters 128
and up are displayed with octal escape sequences; thus, character code
243 (octal), also called `M-#' when used as an input character, is
displayed as `\243'.
The variable `ctl-arrow' may be used to alter this behavior. *Note
Display Vars::.
File: emacs, Node: Commands, Next: Pull-down Menus, Prev: Character Representation, Up: Top
Keys and Commands
=================
This manual is full of passages that tell you what particular keys
do. But Emacs does not assign meanings to keys directly. Instead,
Emacs assigns meanings to "functions", and then gives keys their
meanings by "binding" them to functions.
A function is a Lisp object that can be executed as a program.
Usually it is a Lisp symbol that has been given a function definition;
every symbol has a name, usually made of a few English words separated
by dashes, such as `next-line' or `forward-word'. It also has a
"definition", which is a Lisp program. Only some functions can be the
bindings of keys; these are functions whose definitions use
`interactive' to specify how to call them interactively. Such
functions are called "commands", and their names are "command names".
More information on this subject will appear in the GNU Emacs Lisp
Manual.
The bindings between keys and functions are recorded in various
tables called "keymaps". *Note Key Bindings:: for more information on
key sequences you can bind commands to. *Note Keymaps:: for
information on creating keymaps.
When we say "`C-n' moves down vertically one line" we are glossing
over a distinction that is irrelevant in ordinary use but is vital in
understanding how to customize Emacs. The function `next-line' is
programmed to move down vertically. `C-n' has this effect because it
is bound to that function. If you rebind `C-n' to the function
`forward-word' then `C-n' will move forward by words instead.
Rebinding keys is a common method of customization.
The rest of this manual usually ignores this subtlety to keep
things simple. To give the customizer the information needed, we often
state the name of the command that really does the work in parentheses
after mentioning the key that runs it. For example, we will say that
"The command `C-n' (`next-line') moves point vertically down," meaning
that `next-line' is a command that moves vertically down and `C-n' is
a key that is standardly bound to it.
While we are on the subject of information for customization only,
it's a good time to tell you about "variables". Often the description
of a command will say, "To change this, set the variable
`mumble-foo'." A variable is a name used to remember a value. Most
of the variables documented in this manual exist just to facilitate
customization: some command or other part of Emacs uses the variable
and behaves differently depending on its setting. Until you are
interested in customizing, you can ignore the information about
variables. When you are ready to be interested, read the basic
information on variables, then the information on individual variables
will make sense. *Note Variables::.
File: emacs, Node: Pull-down Menus, Next: Mouse Selection, Prev: Commands, Up: Top
Lucid GNU Emacs Pull-down Menus
===============================
If you are running Lucid GNU Emacs under X, a menu bar on top of the
Emacs screen provides access to pull-down menus of file, edit, and
help-related commands. The menus provide convenient shortcuts and an
easy interface for novice users. They do not provide additions to the
functionality available via key commands; you can still invoke commands
from the keyboard as in previous versions of Emacs.
File
Perform file and buffer-related operations, such as opening and
closing files, saving and printing buffers, as well as exiting
Emacs.
Edit
Perform standard editing operations, such as cutting, copying,
pasting and killing selected text.
Buffers
Present a menu of buffers for selection as well as the option to
display a buffer list.
Help
Access to Emacs Info.
There are two ways of selecting an item from a pull-down menu:
* Select an item in the menu bar by moving the cursor over it and
click the left mouse-button. Then move the cursor over the item
you want to choose and click left again.
* Select an item in the menu bar by moving the cursor over it and
click and hold the left mouse-button. With the mouse-button
depressed, move the cursor over the item you want, then release
it to make your selection.
If a command in the pull-down menu is not applicable in a given
situation, the command is disabled and its name appears faded. You
cannot invoke items that are faded. For example, most commands on the
Edit menu appear faded until you select text on which they are to
operate; after you select a block of text, edit commands are enabled.
*Note Mouse Selection:: for information on using the mouse to select
text. *Note Using X Selections:: for related information.
There are also `M-x' equivalents for each menu item. To find the
equivalent for any left-button menu item, do the following:
1. Type `C-h k' to get the `Describe Key' prompt.
2. Select the menu item and click.
Emacs displays the function associated with the menu item in a
separate window, usually together with some documentation.
* Menu:
* File Menu:: Items on the File menu.
* Edit Menu:: Items on the Edit menu.
* Buffers Menu:: Information about the Buffers menu
* Help Menu:: Items on the Help menu.
* Menu Customization:: Adding and removing menu items and related
operations.
File: emacs, Node: File Menu, Next: Edit Menu, Prev: Pull-down Menus, Up: Pull-down Menus
The File Menu
.............
The File menu bar item contains the items New Screen, Open File...,
Save Buffer, Save Buffer As..., Revert Buffer, Print Buffer, Delete
Screen, Kill Buffer and Exit Emacs on the pull-down menu. If you
select a menu item, Emacs executes the equivalent command.
New Screen
Creates a new Emacs screen, that is, a new X window running under
the same Emacs process. You can remove the screen using the
Delete Screen menu item. When you remove the last screen, you
exit Emacs and are prompted for confirmation. This is bound to
`C-x 5' by default.
Open File...
Prompts you for a filename and loads that file into a new buffer.
Open File... is equivalent to the Emacs command `find-file' (`C-x
C-f').
Save Buffer
Writes and saves the current Emacs buffer as the latest version
of the current visited file. Save Buffer is equivalent to the
Emacs command `save-buffer' (`C-x C-s').
Save Buffer As...
Writes and saves the current Emacs buffer to the filename you
specify. Save Buffer As... is equivalent to the Emacs command
`write-file' (`C-x C-w').
Revert Buffer
Restores the last saved version of the file to the current
buffer. When you edit a buffer containing a text file, you must
save the buffer before your changes become effective. Use Revert
Buffer if you do not want to keep the changes you have made in
the buffer. Revert Buffer is equivalent to the Emacs command
`revert-file' (`M-x revert-buffer').
Print Buffer
Prints a hardcopy of the current buffer. Equivalent to the Emacs
command `print-buffer' (`M-x print-buffer').
Delete Screen
Allows you to close all but one of the screens created by New
Screen. If you created several Emacs screens belonging to the
same Emacs process, you can close all but one of them. When you
attempt to close the last screen, Emacs informs you that you are
attempting to delete the last screen. You have to choose Exit
Emacs for that.
Kill Buffer...
Prompts you for the name of a buffer to kill. The default is the
name of the currently selected buffer. Kill Buffer is equivalent
to the Emacs command `kill-buffer' (`C-x k').
Exit Emacs
Shuts down (kills) the Emacs process. Equivalent to the Emacs
command `save-buffers-kill-emacs' (`C-x C-c'). Before killing the
Emacs process, the system asks which unsaved buffers to save by
going through the list of all buffers in that Emacs process.
File: emacs, Node: Edit Menu, Next: Buffers Menu, Prev: File Menu, Up: Pull-down Menus
The Edit Menu
.............
The Edit pull-down menu contains the Undo, Cut, Copy, Paste and
Clear menu items. When you select a menu item, Emacs executes the
equivalent command. Most commands on the Edit menu work on a block of
text, the X selection. They appear faded until you select a block of
text (activate a region) with the mouse. *Note Using X Selections::,
*note Killing::., and *note Yanking::. for more information.
Undo
Undoes the previous command. Undo is equivalent to the Emacs
command `undo' (`C-x u').
Cut
Removes the selected text block from the current buffer, makes it
the X clipboard selection, and places it in the kill ring.
Before executing this command, you have to select a region using
Emacs region selection commands or with the mouse.
Copy
Makes a selected text block the X clipboard selection, and places
it in the kill ring. You can select text using one of the Emacs
region selection commands or select a text region with the mouse.
Paste
Inserts the current value of the X clipboard selection in the
current buffer. Note that this is not necessarily the same as
the Emacs `yank' command because the Emacs kill ring and the X
clipboard selection are not the same thing. You can paste in
text you have placed in the clipboard using Copy or Cut. You can
also use Paste to insert text that was pasted into the clipboard
from other applications.
Clear
Removes the selected text block from the current buffer but does
not place it in the kill ring or the X clipboard selection.
File: emacs, Node: Buffers Menu, Next: Help Menu, Prev: Edit Menu, Up: Pull-down Menus
The Buffers Menu
................
The Buffers menu provides a selection of up to ten buffers and the
item List All Buffers, which provides a Buffer List. *Note List
Buffers:: for more information.
File: emacs, Node: Help Menu, Next: Menu Customization, Prev: Buffers Menu, Up: Pull-down Menus
The Help Menu
.............
The Help Menu gives you access to Emacs Info and provides a menu
equivalents for each of the choices you have when using `C-h'. *Note
Help:: for more information.
The Help menu also gives access to UNIX online manual pages via the
UNIX Manual Page option.
File: emacs, Node: Menu Customization, Prev: Help Menu, Up: Pull-down Menus
Customizing Lucid GNU Emacs Menus
---------------------------------
You can customize any of the pull-down menus by adding or removing
menu items and disabling or enabling existing menu items.
The following functions are available:
`add-menu: (MENU-PATH MENU-NAME MENU-ITEMS &OPTIONAL BEFORE)'
Add a menu to the menubar or one of its submenus.
`add-menu-item: (MENU-PATH ITEM-NAME FUNCTION ENABLED-P &OPTIONAL BEFORE)'
Add a menu item to a menu, creating the menu first if necessary.
`delete-menu-item: (PATH)'
Remove the menu item defined by PATH from the menu hierarchy.
`disable-menu-item: (PATH)'
Disable the specified menu item.
`enable-menu-item: (PATH)'
Enable the specified previously disabled menu item.
`relabel-menu-item: (PATH NEW-NAME)'
Change the string of the menu item specified by PATH to NEW-NAME.
Use the function `add-menu' to add a new menu or submenu. If a
menu or submenu of the given name exists already, it is changed.
MENU-PATH identifies the menu under which the new menu should be
inserted. It is a list of strings; for example, `("File")' names the
top-level File menu. `("File" "Foo")' names a hypothetical submenu of
File. If MENU-PATH is `nil', the menu is added to the menubar itself.
MENU-NAME is the string naming the menu to be added.
MENU-ITEMS is a list of menu item descriptions. Each menu item
should be a vector of three elements:
* A string, which is the name of the menu item.
* A symbol naming a command, or a form to evaluate.
* `t' or `nil' to indicate whether the item is selectable.
The optional argument BEFORE is the name of the menu before which
the new menu or submenu should be added. If the menu is already
present, it is not moved.
The function `add-menu-item' adds a menu item to the specified
menu, creating the menu first if necessary. If the named item already
exists, the menu remains unchanged.
MENU-PATH identifies the menu into which the new menu item should
be inserted. It is a list of strings; for example, `("File")' names
the top-level File menu. `("File" "Foo")' names a hypothetical
submenu of File.
ITEM-NAME is the string naming the menu item to add.
FUNCTION is the command to invoke when this menu item is selected.
If it is a symbol, it is invoked with `call-interactively', in the
same way that functions bound to keys are invoked. If it is a list,
the list is simply evaluated.
ENABLED-P controls whether the item is selectable or not.
For example, to make the `rename-file' command available from the
File menu, use the following code:
(add-menu-item '("File") "Rename File" 'rename-file t)
To add a submenu of file management commands using a File Management
item, use the following code:
(add-menu-item '("File" "File Management") "Copy File" 'copy-file t)
(add-menu-item '("File" "File Management") "Delete File" 'delete-file t)
(add-menu-item '("File" "File Management") "Rename File" 'rename-file t)
The optional BEFORE argument is the name of a menu item before
which the new item should be added. If the item is already present, it
is not moved.
To remove a specified menu item from the menu hierarchy, use
`delete-menu-item'.
PATH is a list of strings that identify the position of the menu
item in the menu hierarchy. `("File" "Save")' means the menu item
called Save under the top level File menu. `("Menu" "Foo" "Item")'
means the menu item called Item under the FOO submenu of MENU.
To disable a menu item, use `disable-menu-item'. The disabled menu
item is grayed and can no longer be selected. To make the item
selectable again, use `enable-menu-item'. `disable-menu-item' and
`enable-menu-item' both have the argument PATH.
To change the string of the specified menu item, use
`relabel-menu-item'. This function also takes the argument PATH.
NEW-NAME is the string to which the menu item will be changed.
File: emacs, Node: Entering Emacs, Next: Exiting, Prev: Mouse Selection, Up: Top
Entering and Exiting Emacs
**************************
The usual way to invoke Emacs is to type `emacs RET' at the shell.
To invoke Lucid GNU Emacs, type `lemacs RET'. Emacs clears the screen
and then displays an initial advisory message and copyright notice.
You can begin typing Emacs commands immediately afterward.
Some operating systems insist on discarding all type-ahead when
Emacs starts up; they give Emacs no way to prevent this. Therefore,
it is wise to wait until Emacs clears the screen before typing the
first editing command.
Before Emacs reads the first command, you have not had a chance to
give a command to specify a file to edit. Since Emacs must always
have a current buffer for editing, it presents a buffer, by default, a
buffer named `*scratch*'. The buffer is in Lisp Interaction mode; you
can use it to type Lisp expressions and evaluate them, or you can
ignore that capability and simply doodle. You can specify a different
major mode for this buffer by setting the variable
`initial-major-mode' in your init file. *Note Init File::.
It is possible to give Emacs arguments in the shell command line to
specify files to visit, Lisp files to load, and functions to call.
File: emacs, Node: Exiting, Next: Command Switches, Prev: Entering Emacs, Up: Top
Exiting Emacs
=============
There are two commands for exiting Emacs because there are two kinds
of exiting: "suspending" Emacs and "killing" Emacs. "Suspending"
means stopping Emacs temporarily and returning control to its superior
(usually the shell), allowing you to resume editing later in the same
Emacs job, with the same files, same kill ring, same undo history, and
so on. This is the usual way to exit. "Killing" Emacs means
destroying the Emacs job. You can run Emacs again later, but you will
get a fresh Emacs; there is no way to resume the same editing session
after it has been killed.
`C-z'
Suspend Emacs (`suspend-emacs'). If used under the X window
system, shrink the X window containing the Emacs screen to an
icon. (see below)
`C-x C-c'
Kill Emacs (`save-buffers-kill-emacs').
If you use Lucid GNU Emacs under the X window system, `C-z' shrinks
the X window containing the Emacs screen to an icon. The Emacs process
is stopped temporarily, and control is returned to the window manager.
If more than one screen is associated with the Emacs process, only the
screen from which you used `C-z' is retained. The X windows
containing the other Emacs screens are closed.
To activate the "suspended" Emacs, use the appropriate window
manager mouse gestures. Usually left-clicking on the icon reactivates
and reopens the X window containing the Emacs screen, but the window
manager you use determines what exactly happens. To actually kill the
Emacs process, use `C-x C-c' or the Exit Emacs item on the File menu.
On systems that do not permit programs to be suspended, `C-z' runs
an inferior shell that communicates directly with the terminal, and
Emacs waits until you exit the subshell. On these systems, the only
way to return to the shell from which Emacs was started (to log out,
for example) is to kill Emacs. `C-d' or `exit' are typical commands
to exit a subshell.
To kill Emacs, type `C-x C-c' (`save-buffers-kill-emacs'). A
two-character key is used for this to make it harder to type. In Lucid
GNU Emacs, selecting the Exit Emacs option of the File menu is an
alternate way of issuing the command.
Unless a numeric argument is used, this command first offers to
save any modified buffers. If you do not save all buffers, you are
asked for reconfirmation with `yes' before killing Emacs, since any
changes not saved will be lost. If any subprocesses are still
running, `C-x C-c' asks you to confirm killing them, since killing
Emacs kills the subprocesses simultaneously.
In most programs running on Unix, certain characters may instantly
suspend or kill the program. (In Berkeley Unix these characters are
normally `C-z' and `C-c'.) This Unix feature is turned off while you
are in Emacs. The meanings of `C-z' and `C-x C-c' as keys in Emacs
were inspired by the standard Berkeley Unix meanings of `C-z' and
`C-c', but that is their only relationship with Unix. You could
customize these keys to do anything (*note Keymaps::.).
File: emacs, Node: Command Switches, Next: Basic, Prev: Exiting, Up: Top
Command Line Switches and Arguments
===================================
GNU Emacs supports command line arguments you can use to request
various actions when invoking Emacs. The commands are for
compatibility with other editors and for sophisticated activities. If
you are using Lucid GNU Emacs under the X window system, you can also
use a number of standard Xt command line arguments. Command line
arguments are not usually needed for editing with Emacs; new users can
skip this section.
Many editors are designed to be started afresh each time you want to
edit. You start the editor to edit one file; then exit the editor.
The next time you want to edit either another file or the same one, you
start the editor again. Under these circumstances, it makes sense to
use a command line argument to say which file to edit.
The recommended way to use GNU Emacs is to start it only once, just
after you log in, and do all your editing in the same Emacs process.
Each time you want to edit a file, you visit it using the existing
Emacs. Emacs creates a new buffer for each file and (unless you kill
some of the buffers), Emacs eventually has many files in it ready for
editing. Usually you do not kill the Emacs process until you are about
to log out. Since you usually read files by typing commands to Emacs,
command line arguments for specifying a file Emacs is started are
seldom needed.
Emacs accepts command-line arguments that specify files to visit,
functions to call, and other activities and operating modes. If you
are running Lucid GNU Emacs under the X window system, a number of
standard Xt command line arguments are available as well.
The following sections list:
* Command line arguments that you can always use.
* Command line arguments that have to appear at the beginning of the
argument list.
* Command line arguments that are only relevant if you are running
Lucid GNU Emacs under X.
Command line arguments are processed in the order they appear on the
command line; however, certain arguments (the ones in the second
table) must be at the front of the list if they are used.
Here are the arguments allowed:
`FILE'
Visit FILE using `find-file'. *Note Visiting::.
`+LINENUM FILE'
Visit FILE using `find-file', then go to line number LINENUM in
it.
`-l FILE'
`-load FILE'
Load a file FILE of Lisp code with the function `load'. *Note
Lisp Libraries::.
`-f FUNCTION'
`-funcall FUNCTION'
Call Lisp function FUNCTION with no arguments.
`-i FILE'
`-insert FILE'
Insert the contents of FILE into the current buffer. This is like
what `M-x insert-buffer' does; *Note Misc File Ops::.
`-kill'
Exit from Emacs without asking for confirmation.
`-version'
Prints version information. This implies `-batch'.
% emacs -version
GNU Emacs 19.4 Lucid of Mon Dec 28 1992 on thalidomide (berkeley-unix)
`-help'
Prints a summary of command-line options, and exits.
The following arguments are recognized only at the beginning of the
command line. If more than one of them appears, they must appear in
the order in which they appear in this table.
`-t FILE'
Use FILE instead of the terminal for input and output. (This
option is currently not valid in Lucid GNU Emacs)
`-batch'
Run Emacs in "batch mode", which means that the text being edited
is not displayed and the standard Unix interrupt characters such
as `C-z' and `C-c' continue to have their normal effect. Emacs in
batch mode outputs to `stderr' only what would normally be printed
in the echo area under program control.
Batch mode is used for running programs written in Emacs Lisp
from shell scripts, makefiles, and so on. Normally the `-l'
switch or `-f' switch will be used as well, to invoke a Lisp
program to do the batch processing.
`-batch' implies `-q' (do not load an init file). It also causes
Emacs to kill itself after all command switches have been
processed. In addition, auto-saving is not done except in
buffers for which it has been explicitly requested.
`-q'
`-no-init-file'
Do not load your Emacs init file `~/.emacs'.
`-u USER'
`-user USER'
Load USER's Emacs init file `~USER/.emacs' instead of your own.
Note that the init file can get access to the command line argument
values as the elements of a list in the variable `command-line-args'.
(The arguments in the second table above will already have been
processed and will not be in the list.) The init file can override
the normal processing of the other arguments by setting this variable.
One way to use command switches is to visit many files
automatically:
emacs *.c
passes each `.c' file as a separate argument to Emacs, so that Emacs
visits each file (*note Visiting::.).
Here is an advanced example that assumes you have a Lisp program
file called `hack-c-program.el' which, when loaded, performs some
useful operation on the current buffer, expected to be a C program.
emacs -batch foo.c -l hack-c-program -f save-buffer -kill > log
Here Emacs is told to visit `foo.c', load `hack-c-program.el' (which
makes changes in the visited file), save `foo.c' (note that
`save-buffer' is the function that `C-x C-s' is bound to), and then
exit to the shell from which the command was executed. `-batch'
guarantees there will be no problem redirecting output to `log',
because Emacs will not assume that it has a display terminal to work
with.
If you are running Lucid GNU Emacs under X, a number of options are
available to control color, border, and window title and icon name:
`-T TITLE'
`-wn TITLE'
Use TITLE as the window title. This sets the
`screen-title-format' variable, which controls the title of the X
window corresponding to the selected screen. This is the same
format as `mode-line-format'.
`-in TITLE'
`-iconname TITLE'
Use TITLE as the icon name. This sets the
`screen-icon-title-format' variable, which controls the title of
the icon corresponding to the selected screen.
`-mc COLOR'
Use COLOR as the mouse color.
`-cr COLOR'
Use COLOR as the text-cursor foreground color.
In addition, Lucid GNU Emacs allows you to use a number of standard
Xt command line arguments.
`-bg COLOR'
`-background COLOR'
Use COLOR as the background color.
`-bd COLOR'
`-bordercolor COLOR'
Use COLOR as the border color.
`-bw WIDTH'
`-borderwidth WIDTH'
Use WIDTH as the border width.
`-d DISPLAY'
`-display DISPLAY'
`-d DISPLAY'
When running under the X window system, create the window
containing the Emacs screen on the display named DISPLAY.
`-fg COLOR'
`-foreground COLOR'
Use COLOR as the foreground color.
`-fn NAME'
`-font NAME'
Use NAME as the font.
`-g SPEC'
`-geom SPEC'
`-geometry SPEC'
Use the geometry specified by SPEC.
`- iconic'
Start up iconified.
`-r'
`-reverse'
Bring up Emacs in reverse video.
`-name'
Use the resource manager specified by NAME.
`-xrm'
Read something into the resource database for this invocation of
Emacs.
`-title TITLE'
Same as `-wn', sets the window title using `window-title-format'.
File: emacs, Node: Basic, Next: Undo, Prev: Command Switches, Up: Top
Basic Editing Commands
**********************
We now give the basics of how to enter text, make corrections, and
save the text in a file. If this material is new to you, you might
learn it more easily by running the Emacs learn-by-doing tutorial. To
do this, type `Control-h t' (`help-with-tutorial').
Inserting Text
==============
To insert printing characters into the text you are editing, just
type them. This inserts the characters into the buffer at the cursor
(that is, at "point"; *note Point::.). The cursor moves forward. Any
characters after the cursor move forward too. If the text in the
buffer is `FOOBAR', with the cursor before the `B' and you type `XX',
the result is `FOOXXBAR', with the cursor still before the `B'.
To "delete" text you have just inserted, use DEL. DEL deletes the
character BEFORE the cursor (not the one that the cursor is on top of
or under; that is the character AFTER the cursor). The cursor and all
characters after it move backwards. Therefore, if you type a printing
character and then type DEL, they cancel out.
To end a line and start typing a new one, type RET. This inserts a
newline character in the buffer. If point is in the middle of a line,
RET splits the line. Typing DEL when the cursor is at the beginning
of a line rubs out the newline before the line, thus joining the line
with the preceding line.
Emacs automatically splits lines when they become too long, if you
turn on a special mode called "Auto Fill" mode. *Note Filling::, for
information on using Auto Fill mode.
Customization information: DEL, in most modes, runs the command
`delete-backward-char'; RET runs the command `newline', and
self-inserting printing characters run the command `self-insert',
which inserts whatever character was typed to invoke it. Some major
modes rebind DEL to other commands.
Direct insertion works for printing characters and SPC, but other
characters act as editing commands and do not insert themselves. If
you need to insert a control character or a character whose code is
above 200 octal, you must "quote" it by typing the character
`control-q' (`quoted-insert') first. There are two ways to use `C-q':
* `Control-q' followed by any non-graphic character (even `C-g')
inserts that character.
* `Control-q' followed by three octal digits inserts the character
with the specified character code.
A numeric argument to `C-q' specifies how many copies of the quoted
character should be inserted (*note Arguments::.).
If you prefer to have text characters replace (overwrite) existing
text instead of moving it to the right, you can enable Overwrite mode,
a minor mode. *Note Minor Modes::.
Changing the Location of Point
==============================
To do more than insert characters, you have to know how to move
point (*note Point::.). Here are a few of the available commands.
`C-a'
Move to the beginning of the line (`beginning-of-line').
`C-e'
Move to the end of the line (`end-of-line').
`C-f'
Move forward one character (`forward-char').
`C-b'
Move backward one character (`backward-char').
`M-f'
Move forward one word (`forward-word').
`M-b'
Move backward one word (`backward-word').
`C-n'
Move down one line, vertically (`next-line'). This command
attempts to keep the horizontal position unchanged, so if you
start in the middle of one line, you end in the middle of the
next. When on the last line of text, `C-n' creates a new line
and moves onto it.
`C-p'
Move up one line, vertically (`previous-line').
`C-l'
Clear the screen and reprint everything (`recenter'). Text moves
on the screen to bring point to the center of the window.
`M-r'
Move point to left margin on the line halfway down the screen or
window (`move-to-window-line'). Text does not move on the
screen. A numeric argument says how many screen lines down from
the top of the window (zero for the top). A negative argument
counts from the bottom (-1 for the bottom).
`C-t'
Transpose two characters, the ones before and after the cursor
(`transpose-chars').
`M-<'
Move to the top of the buffer (`beginning-of-buffer'). With
numeric argument N, move to N/10 of the way from the top. *Note
Arguments::, for more information on numeric arguments.
`M->'
Move to the end of the buffer (`end-of-buffer').
`M-x goto-char'
Read a number N and move the cursor to character number N.
Position 1 is the beginning of the buffer.
`M-x goto-line'
Read a number N and move cursor to line number N. Line 1 is the
beginning of the buffer.
`C-x C-n'
Use the current column of point as the "semi-permanent goal
column" for `C-n' and `C-p' (`set-goal-column'). Henceforth,
those commands always move to this column in each line moved
into, or as close as possible given the contents of the line.
This goal column remains in effect until canceled.
`C-u C-x C-n'
Cancel the goal column. Henceforth, `C-n' and `C-p' once again
try to avoid changing the horizontal position, as usual.
If you set the variable `track-eol' to a non-`nil' value, `C-n' and
`C-p' move to the end of the line when at the end of the starting
line. By default, `track-eol' is `nil'.
Erasing Text
============
`DEL'
Delete the character before the cursor (`delete-backward-char').
`C-d'
Delete the character after the cursor (`delete-char').
`C-k'
Kill to the end of the line (`kill-line').
`M-d'
Kill forward to the end of the next word (`kill-word').
`M-DEL'
Kill back to the beginning of the previous word
(`backward-kill-word').
In contrast to the DEL key, which deletes the character before the
cursor, `Control-d' deletes the character after the cursor, causing
the rest of the text on the line to shift left. If `Control-d' is
typed at the end of a line, that line and the next line are joined.
To erase a larger amount of text, use `Control-k', which kills a
line at a time. If you use `C-k' at the beginning or in the middle of
a line, it kills all the text up to the end of the line. If you use
`C-k' at the end of a line, it joins that line and the next line.
*Note Killing::, for more flexible ways of killing text.
Files
=====
The commands above are sufficient for creating and altering text in
an Emacs buffer. More advanced Emacs commands just make things
easier. But to keep any text permanently you must put it in a "file".
Files are named units of text which are stored by the operating
system and which you can retrieve by name. To look at or use the
contents of a file in any way, including editing the file with Emacs,
you must specify the file name.
Consider a file named `/usr/rms/foo.c'. To begin editing this file
from Emacs, type
C-x C-f /usr/rms/foo.c RET
The file name is given as an "argument" to the command `C-x C-f'
(`find-file'). The command uses the "minibuffer" to read the
argument. You have to type RET to terminate the argument (*note
Minibuffer::.).
You can also use the Open File... menu item from the File menu, then
type the name of the file to the prompt.
Emacs obeys the command by "visiting" the file: it creates a
buffer, copies the contents of the file into the buffer, and then
displays the buffer for you to edit. You can make changes in the
buffer, and then "save" the file by typing `C-x C-s' (`save-buffer')
or choosing Save Buffer from the File menu. This makes the changes
permanent by copying the altered contents of the buffer back into the
file `/usr/rms/foo.c'. Until then, the changes are only inside your
Emacs buffer, and the file `foo.c' is not changed.
To create a file, visit the file with `C-x C-f' as if it already
existed or choose Open File from the File menu and provide the name
for the new file in the minibuffer. Emacs will create an empty buffer
in which you can insert the text you want to put in the file. When
you save the buffer with `C-x C-s', or by choosing Save Buffer from
the File menu, the file is created.
To learn more about using files, *note Files::..
Help
====
If you forget what a key does, you can use the Help character,
`C-h' to find out: Type `C-h k' followed by the key you want to know
about. For example, `C-h k C-n' tells you what `C-n' does. `C-h' is
a prefix key; `C-h k' is just one of its subcommands (the command
`describe-key'). The other subcommands of `C-h' provide different
kinds of help. Type `C-h' three times to get a description of all the
help facilities. *Note Help::.
* Menu:
* Blank Lines:: Commands to make or delete blank lines.
* Continuation Lines:: Lines too wide for the screen.
* Position Info:: What page, line, row, or column is point on?
* Arguments:: Numeric arguments for repeating a command.
File: emacs, Node: Blank Lines, Next: Continuation Lines, Prev: Basic, Up: Basic
Blank Lines
===========
Here are special commands and techniques for entering and removing
blank lines.
`C-o'
Insert one or more blank lines after the cursor (`open-line').
`C-x C-o'
Delete all but one of many consecutive blank lines
(`delete-blank-lines').
When you want to insert a new line of text before an existing line,
you just type the new line of text, followed by RET. If you prefer to
first create a blank line and then insert the desired text, use the
key `C-o' (`open-line'), which inserts a newline after point but
leaves point in front of the newline. Then type the text into the new
line. `C-o F O O' has the same effect as `F O O RET', except for the
final location of point.
To create several blank lines, type `C-o' several times, or give
`C-o' an argument indicating how many blank lines to create. *Note
Arguments::, for more information.
If you have many blank lines in a row and want to get rid of them,
use `C-x C-o' (`delete-blank-lines'). If point is on a blank line
which is adjacent to at least one other blank line, `C-x C-o' deletes
all but one of the blank lines. If point is on a blank line with no
other adjacent blank line, the sole blank line is deleted. If point
is on a non-blank line, `C-x C-o' deletes any blank lines following
that non-blank line.
File: emacs, Node: Continuation Lines, Next: Position Info, Prev: Blank Lines, Up: Basic
Continuation Lines
==================
If you add too many characters to one line without breaking with a
RET, the line grows to occupy two (or more) screen lines, with a
curved arrow at the extreme right margin of all but the last line. The
curved arrow indicates that the following screen line is not really a
distinct line in the text, but just the "continuation" of a line too
long to fit the screen. You can use Auto Fill mode, (*note
Filling::.), to have Emacs insert newlines automatically when a line
gets too long.
Instead of continuation, long lines can be displayed by
"truncation". This means that all the characters that do not fit in
the width of the screen or window do not appear at all. They remain
in the buffer, temporarily invisible. Three diagonal dots in the last
column (instead of the curved arrow inform you that truncation is in
effect.
To turn off continuation for a particular buffer set the variable
`truncate-lines' to non-`nil' in that buffer. Truncation instead of
continuation also happens whenever horizontal scrolling is in use, and
optionally whenever side-by-side windows are in use (*note
Windows::.). Altering the value of `truncate-lines' makes it local to
the current buffer; until that time, the default value is in effect.
The default is initially `nil'. *Note Locals::.
File: emacs, Node: Position Info, Next: Arguments, Prev: Continuation Lines, Up: Basic
Cursor Position Information
===========================
If you are accustomed to other display editors, you may be surprised
that Emacs does not always display the page number or line number of
point in the mode line. In Emacs, this information is only rarely
needed, and a number of commands are available to compute and print it.
Since text is stored in a way that makes it difficult to compute the
information, it is not displayed all the time.
`M-x what-page'
Print page number of point, and line number within page.
`M-x what-line'
Print line number of point in the buffer.
`M-='
Print number of lines in the current region
(`count-lines-region').
`C-x ='
Print character code of character after point, character position
of point, and column of point (`what-cursor-position').
There are several commands for printing line numbers:
* `M-x what-line' counts lines from the beginning of the file and
prints the line number point is on. The first line of the file
is line number 1. You can use these numbers as arguments to `M-x
goto-line'.
* `M-x what-page' counts pages from the beginning of the file, and
counts lines within the page, printing both of them. *Note
Pages::, for the command `C-x l' which counts the lines in the
current page.
* `M-=' (`count-lines-region'), prints the number of lines in the
region (*note Mark::.).
The command `C-x =' (`what-cursor-position') provides information
about point and about the column the cursor is in. It prints a line
in the echo area that looks like this:
Char: x (0170) point=65986 of 563027(12%) x=44
(In fact, this is the output produced when point is before the `x=44'
in the example.)
The two values after `Char:' describe the character following point,
first by showing it and second by giving its octal character code.
`point=' is followed by the position of point expressed as a
character count. The front of the buffer counts as position 1, one
character later as 2, and so on. The next, larger number is the total
number of characters in the buffer. Afterward in parentheses comes
the position expressed as a percentage of the total size.
`x=' is followed by the horizontal position of point, in columns
from the left edge of the window.
If the buffer has been narrowed, making some of the text at the
beginning and the end temporarily invisible, `C-x =' prints additional
text describing the current visible range. For example, it might say
Char: x (0170) point=65986 of 563025(12%) <65102 - 68533> x=44
where the two extra numbers give the smallest and largest character
position that point is allowed to assume. The characters between
those two positions are the visible ones. *Note Narrowing::.
If point is at the end of the buffer (or the end of the visible
part), `C-x =' omits any description of the character after point.
The output looks like
point=563026 of 563025(100%) x=0
File: emacs, Node: Arguments, Prev: Position Info, Up: Basic
Numeric Arguments
=================
Any Emacs command can be given a "numeric argument". Some commands
interpret the argument as a repetition count. For example, giving an
argument of ten to the key `C-f' (the command `forward-char', move
forward one character) moves forward ten characters. With these
commands, no argument is equivalent to an argument of one. Negative
arguments are allowed. Often they tell a command to move or act
backwards.
If your keyboard has a META key, the easiest way to specify a
numeric argument is to type digits and/or a minus sign while holding
down the the META key. For example,
M-5 C-n
moves down five lines. The characters `Meta-1', `Meta-2', and so on,
as well as `Meta--', do this because they are keys bound to commands
(`digit-argument' and `negative-argument') that are defined to
contribute to an argument for the next command.
Another way of specifying an argument is to use the `C-u'
(`universal-argument') command followed by the digits of the argument.
With `C-u', you can type the argument digits without holding down
shift keys. To type a negative argument, start with a minus sign.
Just a minus sign normally means -1. `C-u' works on all terminals.
`C-u' followed by a character which is neither a digit nor a minus
sign has the special meaning of "multiply by four". It multiplies the
argument for the next command by four. `C-u' twice multiplies it by
sixteen. Thus, `C-u C-u C-f' moves forward sixteen characters. This
is a good way to move forward "fast", since it moves about 1/5 of a
line in the usual size screen. Other useful combinations are `C-u
C-n', `C-u C-u C-n' (move down a good fraction of a screen), `C-u C-u
C-o' (make "a lot" of blank lines), and `C-u C-k' (kill four lines).
Some commands care only about whether there is an argument, and not
about its value. For example, the command `M-q' (`fill-paragraph')
with no argument fills text; with an argument, it justifies the text
as well. (*Note Filling::, for more information on `M-q'.) Just
`C-u' is a handy way of providing an argument for such commands.
Some commands use the value of the argument as a repeat count, but
do something peculiar when there is no argument. For example, the
command `C-k' (`kill-line') with argument N kills N lines, including
their terminating newlines. But `C-k' with no argument is special: it
kills the text up to the next newline, or, if point is right at the
end of the line, it kills the newline itself. Thus, two `C-k'
commands with no arguments can kill a non-blank line, just like `C-k'
with an argument of one. (*Note Killing::, for more information on
`C-k'.)
A few commands treat a plain `C-u' differently from an ordinary
argument. A few others may treat an argument of just a minus sign
differently from an argument of -1. These unusual cases will be
described when they come up; they are always for reasons of convenience
of use of the individual command.
File: emacs, Node: Undo, Next: Minibuffer, Prev: Basic, Up: Top
Undoing Changes
***************
Emacs allows you to undo all changes you make to the text of a
buffer, up to a certain amount of change (8000 characters). Each
buffer records changes individually, and the undo command always
applies to the current buffer. Usually each editing command makes a
separate entry in the undo records, but some commands such as
`query-replace' make many entries, and very simple commands such as
self-inserting characters are often grouped to make undoing less
tedious.
`C-x u'
Undo one batch of changes (usually, one command worth) (`undo').
`C-_'
The same.
The command `C-x u' or `C-_' allows you to undo changes. The first
time you give this command, it undoes the last change. Point moves to
the text affected by the undo, so you can see what was undone.
Consecutive repetitions of the `C-_' or `C-x u' commands undo
earlier and earlier changes, back to the limit of what has been
recorded. If all recorded changes have already been undone, the undo
command prints an error message and does nothing.
Any command other than an undo command breaks the sequence of undo
commands. Starting at this moment, the previous undo commands are
considered ordinary changes that can themselves be undone. Thus, you
can redo changes you have undone by typing `C-f' or any other command
that have no important effect, and then using more undo commands.
If you notice that a buffer has been modified accidentally, the
easiest way to recover is to type `C-_' repeatedly until the stars
disappear from the front of the mode line. When that happens, all the
modifications you made have been cancelled. If you do not remember
whether you changed the buffer deliberately, type `C-_' once. When you
see Emacs undo the last change you made, you probably remember why you
made it. If the change was an accident, leave it undone. If it was
deliberate, redo the change as described in the preceding paragraph.
Whenever an undo command makes the stars disappear from the mode
line, the buffer contents is the same as it was when the file was last
read in or saved.
Not all buffers record undo information. Buffers whose names start
with spaces don't; these buffers are used internally by Emacs and its
extensions to hold text that users don't normally look at or edit.
Minibuffers, help buffers and documentation buffers also don't record
undo information.
Emacs can remember at most 8000 or so characters of deleted or
modified text in any one buffer for reinsertion by the undo command.
There is also a limit on the number of individual insert, delete or
change actions that Emacs can remembered.
There are two keys to run the `undo' command, `C-x u' and `C-_',
because on some keyboards, it is not obvious how to type `C-_'. `C-x
u' is an alternative you can type in the same fashion on any terminal.